home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
Hot Super Models
/
Hot Super Models.iso
/
unix
/
x11
/
xv200.tar
/
xv-2.00
/
docs
/
INFO.OLD
< prev
next >
Wrap
Text File
|
1992-01-01
|
10KB
|
201 lines
Note: This is pretty well obsolete, but may be of interest to any one who
feels like hacking 'xv'
--jhb, 8/31/90
------------------------------------------------------------------------------
general concepts:
1. main program should do command line parsing, call a LOAD routine of some
sort, and display the result. It will sit in a loop parsing keyboard
commands until a file-changing command is given.
Keyboard Commands:
Q: quit
CR,SP: next file
BS,DEL: previous file
,: shrink picture 10%
.: grow picture 10%
<: shrink picture by factor of 2
>: grow picture by factor of 2
N: home. (Show picture at normal size)
M: max. (grow picture to size of screen)
C: crop picture
U: uncrop picture
I: info box
4: 4x3-ify the picture
Mouse Commands:
Button1: lets you draw a cropping rectangle
Button2:
Button3:
2. LOAD routines: given a file name. They'll do optional suffix-tacking-on
if they wish to. They will do whatever needs to be done to the picture
to get it into an 8-plane image with a colormap.
The load routines will return several things (in global variables):
pWIDE, pHIGH, a pWIDE*pHIGH array of pixels (pic) (one byte per), 0,0 is
the top-left corner of the image, a colormap (three 256-element arrays
of bytes, for r,g and b (called 'r', 'g', and 'b', oddly enough)
load routines will return '0' if successful, a slew of non-zero things if
not
3. A common routine for colormap sort/compression (SortColormap()).
the colormap will be compressed. That is, if only 37 colors
in the 256-element colormap are used, they will be the first 37 entries
in the colormap. This way, the display portion of the code won't waste
resources allocating unused colors. This routine will also modify the
PIC array accordingly.
This routine calculates 'numcols'.
Thought: have the colormap compression algorithm sort the colormap
so that the most-used color is first, and the other colors are in order
of decreasing distance from the first color. (That is, the second color
will be the 'most unlike' the first color, the third color will be the
'second most unlike' the first color, and so on.)
Justification: Since we allocate colors in the order they're stored
in the colormap, it'd probably be better to get all the major colors
first, and then pick up the subtle shade differences if there's any
colors left.
Improved sort algorithm. Slower, but possibly more desirable.
(besides, the speed of this routine is not likely to be a problem)
Problem with previous algorithm: a picture with a blue sky, a green
ground, and a dark blue car. The previous algorithm will allocate the
sky blue (most used), and then try to allocate ALL THE SHADES OF GREEN
before trying for the dark blue. Suboptimal.
Solution, find the most used color, put it first in the cmap.
find the color the greatest distance from that, put it second in the cmap
NOW, find the color that is farthest away from BOTH of those colors
(that is, for each color left in the cmap, compute the min of it's
distances from the ones that have been allocated already. Then, take the
one that's got the largest min distance and allocate it. continue)
Still more modification to sort algorithm: The modified algorithm
described above is a good thing, but runs on the order O(3). Practical
upshot is that doing it for all 256 colors in a picture takes far too
long. New idea: run that algorithm for the first 32 colors (an
arbitrary smallish number, and plenty fast), then sort the remaining
colors in order of decreasing use.
4. A common routine for 24-bit RGB -> 8 bit colormap conversion.
Since several different data formats might want to do this, this
routine will exist for their calling pleasure. Input will be a wide*high
* 3 byte array of pixels, 3 bytes per (in order R, G, and B). The
procedure will do the 'thing' and store results in all the global
variables that the load routines are supposed to return. A load routine
should be able to just call this routine (once it's built the 24-bit
image) and return.
Input will also be number of colors to use. That is, while it will still
produce a 8-bit PIC array, you might want it to only use 16 colors,
rather than 256. (Say, if you're on a 4 bit display). The reason you'd
want it to do this is that it'll probably do a better job of creating a
16-color picture than the DISPLAY routine would (if it was handed a 256
color picture and asked to display it on a 16-color display).
The 24to8 routine (Conv24to8) will be clever, and if it knows you're
displaying on a monochrome screen (or -mono is set) or that you're
displaying on a 1-bit display (or -nc 0), it will just return an
8-bit greyscale version of the picture. This is because running the
full 24-bit RGB to 8-bit pseudocolor conversion takes a long time,
and shouldn't be done if not necessary.
5. Display routines. Do whatever is necessary to show PIC on display.
This includes things like building an Ximage in the correct depth,
expanding/compressing size of image
There will be a AllocColors() routine that will take the desired colormap
and see what it can do, based on the type of display you're using.
This routine will be called once per picture, before doing Resize()
(As Resize() calls CreateXImage()...)
if (based on 'theVisual', or '-mono') we appear to be running on a
GrayScale or StaticGray display, this algorithm will FIRST run through
the desired colormap (the 'epic' colormap) and replace the r,g,b values
for each entry with the corresponding intensity value (I=(.3r+.5g+.2b)/3)
This way, pictures will be correctly displayed on mono screens.
Algorithm: for >1 bit displays (ie, greyscale/color), alloc colors in
the X colormap in the order that the SortColormap routine returned.
Colors that couldn't be allocated are matched to the closest colors in
the global X colormap, or the just the colors allocated (based on the
value of 'noglob')
the 'cols[]' array will hold the mapping between 'epic' colors and X
colors. (ie, color #37 in epic and the epic colormap will correspond to
color # cols[37] in the X image and the X colormap)
the 'freecols[]' array (and nfcols, the length of it) will hold the X
pixel values of the colors that were allocated, so that they may be
later un-allocated. Also, it will NOT have duplicate entries in it.
(ie, if allocating (15,15,15) and (16,16,16) both return pixel #2,
pixel #2 will be in freecols ONCE.)
More algorithm: for 1 bit displays there's only going to be two
colors, 'black' and 'white'. (What the two colors actually look like
on the screen (ie, maybe it's blue and white, or black and green), is
not important. So what we do here is, rather than try to allocate any
colors (it'd probably fail anyhow), run the Floyd Steinberg dithering
algorithm over the picture, and just use 'black' and 'white'
6. There's several variables that seem to do the same thing. They don't.
Here's what they do:
pic, pWIDE, pHIGH: This is the 8-bit image ret. by the load routine
cpic, cWIDE, cHIGH,
cXOFF, cYOFF: This is the cropped version of pic. If there is
no cropping going on, it will point to pic.
cXOFF and cYOFF specify the offset from 0,0 of
the original pic. (ie, pixel cXOFF,cYOFF in the
original picture will be at 0,0 in the cpic image
epic, eWIDE, eHIGH: This is another 8-bit image. This is an expanded/
compressed version of cpic. Generated in the
Resize() function. When there is no expansion
(ie, eWIDE=pWIDE, eHIGH=pHIGH) epic *will* point
to 'cpic'. This way the X conversion routines
can simply use epic, eWIDE, and eHIGH.
theImage: This is an Ximage version of epic. It'll be in whatever
depth/format is deemed appropriate for the X display.
It is generated from epic after epic has been Resize()'d
It's generated in the function CreateXImage()
What happens to a picture from loading to display:
picture is loaded in some native format
(local to LOAD routine)
picture is converted to 8-bit colortable routine (pic)
(in LOAD routine. native format data is thrown away)
LOOP
'pic' is cropped, if desired. cpic points to picture data
'cpic' is expanded, if desired. epic points to data
'epic' is converted to theImage
(an X Format in the depth of the screen)
REPEAT
7. It should be noted that the several functions break on machines where
'int' is <32 bits. These machines are wrong.
8. added a 'perfect' mode, where it installs it's own colormap
9. further thoughts...
add an ability to display multiple iconified-files at once (has to
be done in 'mono' mode... (contact sheets, Hagan calls them)
10. color usage. six colors can be specified via command-line/resource
database. They are white,black, foreground,background, and
info.foreground,info.background. white and black are only used in
the 1-bit dithering routines (FloydDitherize8 and FloydDitherize1)
foreground,background specify the colors of the window/frame
info.{fore,back}ground specifies the colors of the info box